package com.efast.dmom.mgmt.service.les.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.efast.dmom.mgmt.utils.MesConstant;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.efast.cafe.framework.exception.ServiceException;
import com.efast.cafe.framework.jdbc.JdbcDao;
import com.efast.cafe.framework.util.SpringWebUtils;
import com.efast.dmom.mgmt.bean.les.TtMmManualMriBean;
import com.efast.dmom.mgmt.dao.les.TmBasDockDao;
import com.efast.dmom.mgmt.dao.les.TmMmDeliverySheetDao;
import com.efast.dmom.mgmt.dao.les.TmMmDeliverySheetOpDao;
import com.efast.dmom.mgmt.dao.les.TmMmDeliverySheetPartDao;
import com.efast.dmom.mgmt.dao.les.TtMmManualMriDao;
import com.efast.dmom.mgmt.dao.les.TwDocOrderDetailsDao;
import com.efast.dmom.mgmt.dao.les.TwDocOrderHeaderDao;
import com.efast.dmom.mgmt.dao.master.TmBasDlocDao;
import com.efast.dmom.mgmt.dao.master.TmBasLocDao;
import com.efast.dmom.mgmt.dao.master.TmBasPartDao;
import com.efast.dmom.mgmt.dao.master.TmBasWhDao;
import com.efast.dmom.mgmt.dao.master.TrBasPartSupplDao;
import com.efast.dmom.mgmt.entity.les.TmBasDock;
import com.efast.dmom.mgmt.entity.les.TmMmDeliverySheet;
import com.efast.dmom.mgmt.entity.les.TmMmDeliverySheetOp;
import com.efast.dmom.mgmt.entity.les.TmMmDeliverySheetPart;
import com.efast.dmom.mgmt.entity.les.TtMmManualMri;
import com.efast.dmom.mgmt.entity.les.TwDocOrderDetails;
import com.efast.dmom.mgmt.entity.les.TwDocOrderHeader;
import com.efast.dmom.mgmt.entity.master.TmBasDloc;
import com.efast.dmom.mgmt.entity.master.TmBasLoc;
import com.efast.dmom.mgmt.entity.master.TmBasPart;
import com.efast.dmom.mgmt.entity.master.TmBasWh;
import com.efast.dmom.mgmt.entity.master.TrBasPartSuppl;
import com.efast.dmom.mgmt.service.les.TtMmManualMriService;
import com.efast.dmom.mgmt.utils.Assist;

@Service
public class TtMmManualMriServiceImpl implements TtMmManualMriService {

	@Autowired
	private TtMmManualMriDao ttMmManualMriDao;
	// 看板上线单头表 tm_mm_delivery_sheet
	@Autowired
	private TmMmDeliverySheetDao tmMmDeliverySheetDao;
	// 看板上线单明细tm_mm_delivery_sheet_part
	@Autowired
	private TmMmDeliverySheetPartDao tmMmDeliverySheetPartDao;
	// 看板上线单历史记录 tm_mm_delivery_sheet_op
	@Autowired
	private TmMmDeliverySheetOpDao tmMmDeliverySheetOpDao;
	// 出库订单表 detail
	@Autowired
	private TwDocOrderDetailsDao twDocOrderDetailsDao;
	// 出库订单表 header
	@Autowired
	private TwDocOrderHeaderDao twDocOrderHeaderDao;
	// 【主数据】道口 tm_bas_dock
	@Autowired
	private TmBasDockDao tmBasDockDao;
	// 【主数据】零件供应商关系 tr_bas_part_suppl
	@Autowired
	private TrBasPartSupplDao trBasPartSupplDao;
	// 【主数据】零件基本信息 tm_bas_part
	@Autowired
	private TmBasPartDao tmBasPartDao;
	// 【主数据】工厂信息 tm_bas_plant
	/*
	 * @Autowired private TmBasPlantDao tmBasPlantDao;
	 */
	// 【主数据】车间信息 tm_bas_workshop
	/*
	 * @Autowired private TmBasWorkshopDao tmBasWorkshopDao;
	 */
	// 【主数据】仓库信息 tm_bas_workshop
	@Autowired
	private TmBasWhDao tmBasWhDao;
	// 【主数据】库区信息 tm_bas_dloc
	@Autowired
	private TmBasDlocDao tmBasDlocDao;
	// 【主数据】库位信息 tm_bas_loc
	@Autowired
	private TmBasLocDao tmBasLocDao;
	// 生成序列号
	@Qualifier("jdbcDao")
	@Autowired
	private JdbcDao jdbcDao;

	@Override
	public TtMmManualMri selectTtMmManualMriByObj(TtMmManualMri requestTtMmManualMri) {
		// 【1】 判断tt_mm_manual_mri表是否已经存在看板号
		List<TtMmManualMri> list = ttMmManualMriDao.selectTtMmManualMri(
				new Assist(Assist.andEq("tt_mm_manual_mri.pull_unit_no", requestTtMmManualMri.getPullUnitNo())));
		if (list.size() > 0) {
			throw new ServiceException("不能重复扫描看板卡号==>" + requestTtMmManualMri.getPullUnitNo() + "");
		}
		// 【2】 通过看板号 查询出这个看板号相关的信息。
		List<TtMmManualMriBean> listTtMmManualMriBean = ttMmManualMriDao
				.queryInfoByPullUnitNo(requestTtMmManualMri.getPullUnitNo());
		if (listTtMmManualMriBean.size() == 0) {
			throw new ServiceException("找不到看板卡号==>" + requestTtMmManualMri.getPullUnitNo() + "");
		}
		TtMmManualMriBean ttMmManualMriBean = listTtMmManualMriBean.get(0);
		// 【3】将该条记录插入到tt_mm_manual_mri表中。
		TtMmManualMri ttMmManualMri = new TtMmManualMri();
		ttMmManualMri.setCollectTime(new Date()); // 采集时间
		ttMmManualMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
		ttMmManualMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
		BeanUtils.copyProperties(ttMmManualMriBean, ttMmManualMri);
		long time = System.currentTimeMillis() + ttMmManualMriBean.getReqArriveTimeInt() * 60 * 1000;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String date = sdf.format(new Date(time));
		try {
			ttMmManualMri.setReqArriveTime(sdf.parse(date));
		} catch (ParseException e) {
			e.printStackTrace();
			throw new ServiceException("要求送货时间 转换异常");
		}
		// 需求数量=上线包装容量*拉动批量
		Integer needCount = ttMmManualMriBean.getReqQty() * ttMmManualMriBean.getPullQty();
		ttMmManualMri.setReqQty(needCount);
		double reqPackageNum = needCount % ttMmManualMriBean.getSendPackageNum();
		if (reqPackageNum == 0) {
			ttMmManualMri.setReqPackageNum(needCount / ttMmManualMriBean.getSendPackageNum()); // 需求箱数（以发运包装计算）
		} else {
			ttMmManualMri.setReqPackageNum(needCount / ttMmManualMriBean.getSendPackageNum() + 1); // 需求箱数（以发运包装计算）
		}
		ttMmManualMri.setPullType("1"); // 看板模式(上线看板-1，补货看板-2)
		ttMmManualMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
		ttMmManualMri.setMriStatus("0");// 物料需求信息状态((0;未组织，1已组织，2组织失败)
		ttMmManualMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
		ttMmManualMri.setSendStationNo(ttMmManualMriBean.getLocNo());// 送货工位编号
		ttMmManualMri.setDareaNo(ttMmManualMriBean.getDareaNo());// 送货区域编号
		ttMmManualMri.setUseStationNo(ttMmManualMriBean.getLocNo());// 使用工位
		ttMmManualMri.setMriCreateUsername(SpringWebUtils.getRequestUser());
		ttMmManualMri.setCreateTime(new Date());
		ttMmManualMri.setCreateUser(SpringWebUtils.getRequestUser());
		ttMmManualMri.setCompanyCode(SpringWebUtils.getRequestCompany());
		ttMmManualMri.setMarkStatus(1);
		ttMmManualMriDao.insertNonEmptyTtMmManualMri(ttMmManualMri);
		// 【4】将查询出来的记录返回给前台，前台可能会修改 “需求数量”.需求箱数需要自动修改.
		return ttMmManualMri;
	}

	@Override
	public TtMmManualMri selectReplenishmentTtMmManualMriByObj(TtMmManualMri requestTtMmManualMri) {
		// 【1】 判断tt_mm_manual_mri表是否已经存在看板号
		List<TtMmManualMri> list = ttMmManualMriDao.selectTtMmManualMri(
				new Assist(Assist.andEq("tt_mm_manual_mri.pull_unit_no", requestTtMmManualMri.getPullUnitNo())));
		if (list.size() > 0) {
			throw new ServiceException("不难重复扫描看板卡号==>" + requestTtMmManualMri.getPullUnitNo() + "");
		}
		// 【2】 通过看板号 查询出这个看板号相关的信息。
		List<TtMmManualMriBean> listTtMmManualMriBean = ttMmManualMriDao
				.queryReplenishmentInfoByPullUnitNo(requestTtMmManualMri.getPullUnitNo());
		if (listTtMmManualMriBean.size() == 0) {
			throw new ServiceException("找不到看板卡号==>" + requestTtMmManualMri.getPullUnitNo() + "");
		}
		TtMmManualMriBean ttMmManualMriBean = listTtMmManualMriBean.get(0);
		// 【3】将该条记录插入到tt_mm_manual_mri表中。
		TtMmManualMri ttMmManualMri = new TtMmManualMri();
		ttMmManualMri.setCollectTime(new Date()); // 采集时间
		ttMmManualMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
		ttMmManualMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
		BeanUtils.copyProperties(ttMmManualMriBean, ttMmManualMri);
		long time = System.currentTimeMillis() + ttMmManualMriBean.getReqArriveTimeInt() * 60 * 1000;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String date = sdf.format(new Date(time));
		try {
			ttMmManualMri.setReqArriveTime(sdf.parse(date));
		} catch (ParseException e) {
			e.printStackTrace();
			throw new ServiceException("要求送货时间 转换异常");
		}
		// 需求数量=上线包装容量*拉动批量
		Integer needCount = ttMmManualMriBean.getReqQty() * ttMmManualMriBean.getPullQty();
		ttMmManualMri.setReqQty(needCount);
		double reqPackageNum = needCount % ttMmManualMriBean.getSendPackageNum();
		if (reqPackageNum == 0) {
			ttMmManualMri.setReqPackageNum(needCount / ttMmManualMriBean.getSendPackageNum()); // 需求箱数（以发运包装计算）
		} else {
			ttMmManualMri.setReqPackageNum(needCount / ttMmManualMriBean.getSendPackageNum() + 1); // 需求箱数（以发运包装计算）
		}
		ttMmManualMri.setPullType("2"); // 看板模式(上线看板-1，补货看板-2)
		ttMmManualMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
		ttMmManualMri.setMriStatus("0");// 物料需求信息状态((0;未组织，1已组织，2组织失败)
		ttMmManualMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
		ttMmManualMri.setSendStationNo(ttMmManualMriBean.getLocNo());// 送货工位编号
		ttMmManualMri.setDareaNo(ttMmManualMriBean.getDareaNo());// 送货区域编号
		ttMmManualMri.setUseStationNo(ttMmManualMriBean.getLocNo());// 使用工位
		ttMmManualMri.setMriCreateUsername(SpringWebUtils.getRequestUser());
		ttMmManualMri.setCreateTime(new Date());
		ttMmManualMri.setCreateUser(SpringWebUtils.getRequestUser());
		ttMmManualMri.setCompanyCode(SpringWebUtils.getRequestCompany());
		ttMmManualMri.setMarkStatus(1);
		ttMmManualMriDao.insertNonEmptyTtMmManualMri(ttMmManualMri);
		// 【4】将查询出来的记录返回给前台，前台可能会修改 “需求数量”.需求箱数需要自动修改.
		return ttMmManualMri;
	}

	/**
	 * 确认组单
	 */
	@Override
	public void confirmBill(List<Map<String, Object>> listBean) {

		// 根据看板号，查询记录。
		Assist assist = new Assist();
		for (int i = 0; i < listBean.size(); i++) {
			assist.setRequires(Assist.orEq("tt_mm_manual_mri.pull_unit_no", listBean.get(i).get("pullUnitNo")));
		}
		// 查询的结果按照 升序
		assist.setOrder(Assist.order("tt_mm_manual_mri.dpath_id", true));
		List<TtMmManualMri> listTtMmManualMri = ttMmManualMriDao.selectTtMmManualMri(assist);
		if (listTtMmManualMri.size() == 0) {
			throw new ServiceException("通过看板号无法查询到需求记录");
		}

		// 按照路径分组,组成单子.
		Map<String, Object> deliverySheetMap = null;
		Map<String, Object> orderHeaderMap = null;
		int tmMmDeliverySheetId = 0;
		for (int i = 0; i < listTtMmManualMri.size(); i++) {
			// 手工看板需求组织（tt_mm_manual_mri） 实体类
			TtMmManualMri ttMmManualMri = listTtMmManualMri.get(i);
			// 看板上线单头表 tm_mm_delivery_sheet 实体类
			TmMmDeliverySheet tmMmDeliverySheet1 = new TmMmDeliverySheet();
			BeanUtils.copyProperties(ttMmManualMri, tmMmDeliverySheet1);
			// 看板上线单明细tm_mm_delivery_sheet_part 实体类
			TmMmDeliverySheetPart tmMmDeliverySheetPart = new TmMmDeliverySheetPart();
			BeanUtils.copyProperties(ttMmManualMri, tmMmDeliverySheetPart);
			// 第一次的时候，需要向四张表都插入数据。
			if (i == 0) {
				// 【1:看板上线单头表 tm_mm_delivery_sheet】
				deliverySheetMap = insertNonEmptyTmMmDeliverySheet(ttMmManualMri, tmMmDeliverySheetPart,
						tmMmDeliverySheet1);
				tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();

				// 【2:看板上线单明细 tm_mm_delivery_sheet_part】
				int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri, tmMmDeliverySheetPart,
						tmMmDeliverySheet1, (int) deliverySheetMap.get("tmMmDeliverySheetId"),
						(String) deliverySheetMap.get("sheetNo"));

				// 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
				orderHeaderMap = insertNonEmptyTwDocOrderHeader(ttMmManualMri, tmMmDeliverySheetPart,
						tmMmDeliverySheet1, deliverySheetMap);

				// 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
				deliverySheetMap.put("twDocOrderHeaderId", orderHeaderMap.get("twDocOrderHeaderId"));
				deliverySheetMap.put("soSheetNo", orderHeaderMap.get("soSheetNo"));
				deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
				insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
						deliverySheetMap);

				// 【5：产生单据的同时，产生历史记录信息】
				insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetId);
			} else {
				// 第二次的时候需要判断前后记录路径是否相同
				// 如果当前的记录的路径ID和前面一条记录的路径ID相等，则说明两条记录是同一个路径ID，此时只需要插入detail记录，不需要插入头记录。
				if (listTtMmManualMri.get(i).getDpathId().equals(listTtMmManualMri.get(i - 1).getDpathId())) {
					// 【2:看板上线单明细 tm_mm_delivery_sheet_part】
					int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri,
							tmMmDeliverySheetPart, tmMmDeliverySheet1, tmMmDeliverySheetId,
							(String) deliverySheetMap.get("sheetNo"));

					// 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
					deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
					insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
							deliverySheetMap);

				} else {
					deliverySheetMap.clear();
					orderHeaderMap.clear();
					// 【1:看板上线单头表 tm_mm_delivery_sheet】
					deliverySheetMap = insertNonEmptyTmMmDeliverySheet(ttMmManualMri, tmMmDeliverySheetPart,
							tmMmDeliverySheet1);
					tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();

					// 【2:看板上线单明细 tm_mm_delivery_sheet_part】
					int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri,
							tmMmDeliverySheetPart, tmMmDeliverySheet1,
							(int) deliverySheetMap.get("tmMmDeliverySheetId"),
							(String) deliverySheetMap.get("sheetNo"));

					// 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
					orderHeaderMap = insertNonEmptyTwDocOrderHeader(ttMmManualMri, tmMmDeliverySheetPart,
							tmMmDeliverySheet1, deliverySheetMap);

					// 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
					deliverySheetMap.put("soSheetNo", orderHeaderMap.get("soSheetNo"));
					deliverySheetMap.put("twDocOrderHeaderId", orderHeaderMap.get("twDocOrderHeaderId"));
					deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
					insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
							deliverySheetMap);

					// 【5：产生单据的同时，产生历史记录信息】
					insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetId);
				}
			}
		}

		// 根据看板号，查询更新状态记录。
		TtMmManualMri TtMmManualMri = new TtMmManualMri();
		TtMmManualMri.setMriStatus("1");// 物料需求信息状态((0;未组织，1已组织，2组织失败)
		for (int i = 0; i < listBean.size(); i++) {
			Assist assist1 = new Assist();
			assist1.setRequires(Assist.orEq("tt_mm_manual_mri.pull_unit_no", listBean.get(i).get("pullUnitNo")));
			ttMmManualMriDao.updateNonEmptyTtMmManualMri(TtMmManualMri, assist1);
		}

	}

	public Map<String, Object> insertNonEmptyTmMmDeliverySheet(TtMmManualMri ttMmManualMri,
			TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1) {
		String sheetNo = jdbcDao.executeProcGetCode("tm_mm_delivery_sheet", "efast");
		tmMmDeliverySheet1.setSheetNo(sheetNo);// 单号
		tmMmDeliverySheet1.setCommonSheetType("14"); // 对应单证类型14看板上线指示单15看板补货指示单
		tmMmDeliverySheet1.setIsEmergent(1); // 是否紧急拉动单0否1是 默认都是1
		tmMmDeliverySheet1.setSheetStatus("1");// 需求单状态（0新单1发布2部分上线3上线完成4上线失败）
		tmMmDeliverySheet1.setPrintStatus("0");// 打印状态0未打印1已打印
		tmMmDeliverySheetDao.insertNonEmptyTmMmDeliverySheet(tmMmDeliverySheet1);
		Map<String, Object> returnMap = new HashMap<>();
		returnMap.put("tmMmDeliverySheetId", tmMmDeliverySheet1.getTmMmDeliverySheetId());
		returnMap.put("sheetNo", sheetNo);
		return returnMap;
	}

	public void insertNonEmptyTmMmDeliverySheetOp(int tmMmDeliverySheetId) {
		TmMmDeliverySheetOp tmMmDeliverySheetOp = new TmMmDeliverySheetOp();
		tmMmDeliverySheetOp.setTmMmDeliverySheetId(tmMmDeliverySheetId);
		tmMmDeliverySheetOp.setCreateTime(new Date());
		tmMmDeliverySheetOp.setCompanyCode(SpringWebUtils.getRequestCompany());
		tmMmDeliverySheetOp.setCreateUser(SpringWebUtils.getRequestUser());
		tmMmDeliverySheetOp.setOperateNotes("已发布");// 操作备注
		tmMmDeliverySheetOp.setCommonSheetOpType("1");// 拣配单操作类型 需求单状态（0新单1发布2部分上线3上线完成4上线失败）
		tmMmDeliverySheetOp.setOperateUsername(SpringWebUtils.getRequestUser());
		tmMmDeliverySheetOp.setMarkStatus(1);
		tmMmDeliverySheetOpDao.insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetOp);
	}

	public int insertNonEmptyTmMmDeliverySheetPart(TtMmManualMri ttMmManualMri,
			TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1, int tmMmDeliverySheetId,
			String sheetNo) {
		// tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();
		tmMmDeliverySheetPart.setSheetNo(sheetNo);
		tmMmDeliverySheetPart.setTmMmDeliverySheetId(tmMmDeliverySheetId);// 设置detail的关联外键
		tmMmDeliverySheetPart.setMapType("0"); // 对应零件类型\r\n默认都是0 普通零件 因为没有组合零件
		tmMmDeliverySheetPart.setItemStatus("1");// tem状态0新单1已发布
		tmMmDeliverySheetPart.setLinePackageNo(ttMmManualMri.getSendPackageNo());
		tmMmDeliverySheetPart.setReqBoxnum(ttMmManualMri.getReqPackageNum());
		tmMmDeliverySheetPart.setStationArriveTime(ttMmManualMri.getReqArriveTime());
		tmMmDeliverySheetPart.setLinePackageQty(ttMmManualMri.getSendPackageNum());
		tmMmDeliverySheetPartDao.insertNonEmptyTmMmDeliverySheetPart(tmMmDeliverySheetPart);
		return tmMmDeliverySheetPart.getTmMmDeliverySheetPartId();
	}

	public Map<String, Object> insertNonEmptyTwDocOrderHeader(TtMmManualMri ttMmManualMri,
			TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1,
			Map<String, Object> map) {
		// 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
		TwDocOrderHeader twDocOrderHeader = new TwDocOrderHeader();
		twDocOrderHeader.setDockId(tmMmDeliverySheet1.getSendDockId());
		TmBasDock tmBasDock = tmBasDockDao.selectTmBasDockById(tmMmDeliverySheet1.getSendDockId());
		if (StringUtils.isNotBlank(tmBasDock.getDockNo())) {
			twDocOrderHeader.setDockNo(tmBasDock.getDockNo());
		}
		twDocOrderHeader.setCommonSheetType("995"); // 995 对应的是补货看板 common_sheet_type
		String soSheetNo = jdbcDao.executeProcGetCode("tw_doc_order_header", "efast");
		twDocOrderHeader.setSoSheetNo(soSheetNo);
		twDocOrderHeader.setSoSheetStatus("0"); // SO单证状态（新单0、部分分配1、分配完成2、部分拣货3、拣货完成4、部分装箱5、装箱完成6、部分发运7、发运完成8、订单取消9、单证关闭10）
		twDocOrderHeader.setSoSendTime(tmMmDeliverySheet1.getReqArriveTime());
		twDocOrderHeader.setDeliverySend(tmMmDeliverySheet1.getDeliverySend());// 发运地
		twDocOrderHeader.setDeliveryRec(tmMmDeliverySheet1.getDeliveryRec()); // 目的地
		twDocOrderHeader.setCustSheetId((String) map.get("sheetNo"));
		twDocOrderHeader.setCustSheetType("14");
		twDocOrderHeader.setCreateUserType("0");// 创建用户类型(系统自动0，人工1)
		twDocOrderHeader.setMarkStatus(1);
		twDocOrderHeader.setCreateTime(new Date());
		twDocOrderHeader.setCreateUser(SpringWebUtils.getRequestUser());
		twDocOrderHeader.setCompanyCode(SpringWebUtils.getRequestCompany());
		twDocOrderHeaderDao.insertNonEmptyTwDocOrderHeader(twDocOrderHeader);
		Map<String, Object> map1 = new HashMap<>();
		map1.put("dockNo", tmBasDock.getDockNo());
		map1.put("twDocOrderHeaderId", twDocOrderHeader.getTwDocOrderHeaderId());
		map1.put("soSheetNo", soSheetNo);
		return map1;
	}

	public void insertNonEmptyTwDocOrderDetails(TtMmManualMri ttMmManualMri,
			TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1,
			Map<String, Object> map) {
		// tmMmDeliverySheet1.setDeliveryUserId(deliveryUserId); // 送料人ID 上线的时候更新进去
		// 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
		TwDocOrderDetails twDocOrderDetails = new TwDocOrderDetails();
		twDocOrderDetails.setCustomerid(MesConstant.DELIVERY_UNIT_NO);
		List<TwDocOrderDetails> list = twDocOrderDetailsDao.selectTwDocOrderDetails(new Assist(
				Assist.andEq("tw_doc_order_details.tw_doc_order_header_id", (int) map.get("twDocOrderHeaderId"))));
		if (list.size() == 0) {
			twDocOrderDetails.setSoLineno(1); // 行号
		} else {
			twDocOrderDetails.setSoLineno(list.size() + 1); // 行号
		}
		twDocOrderDetails.setLineStatus("0");// 订单行状态（新单0、部分分配1、分配完成2、部分拣货3、拣货完成4、订单取消9、关闭10、分配失败11）
		TrBasPartSuppl trBasPartSuppl = trBasPartSupplDao
				.selectTrBasPartSupplById(tmMmDeliverySheetPart.getTrBasPartSupplId());
		List<TmBasPart> listTmBasPart = tmBasPartDao.selectTmBasPart(
				new Assist(Assist.andEq("tm_bas_part.part_no_version", trBasPartSuppl.getPartNoVersion()),
						Assist.andEq("tm_bas_part.plant_no", trBasPartSuppl.getPlantNo()),
						Assist.andEq("tm_bas_part.workshop_no", trBasPartSuppl.getWorkshopNo())));
		TmBasPart tmBasPart = listTmBasPart.get(0);
		twDocOrderDetails.setPartNamee(tmBasPart.getPartNameE()); // 零件英文名称
		twDocOrderDetails.setTwDocOrderHeaderId((int) map.get("twDocOrderHeaderId"));
		twDocOrderDetails.setPartNoVersion(trBasPartSuppl.getPartNoVersion());// 零件号
		twDocOrderDetails.setPartNamec(tmBasPart.getPartNameC());// 零件中文名称
		twDocOrderDetails.setBaseUnit(tmBasPart.getBaseUnit());// 零件基本单位
		twDocOrderDetails.setSoReqQty(tmMmDeliverySheetPart.getReqQty());// 要求发货数量
		twDocOrderDetails.setSoPackageNo(tmMmDeliverySheetPart.getLinePackageNo());// 要求发货包装编号
		twDocOrderDetails.setSoPackageNum(tmMmDeliverySheetPart.getReqBoxnum()); // '要求发货箱数
		twDocOrderDetails.setCustSheetId((String) map.get("sheetNo"));
		twDocOrderDetails.setCustSheetType("14");
		twDocOrderDetails.setCustSheetLineId((int) map.get("tmMmDeliverySheetPartId"));
		twDocOrderDetails.setSoSheetNo((String) map.get("soSheetNo")); // SO单号',【header】
		twDocOrderDetails.setSoPackageQty(tmMmDeliverySheetPart.getLinePackageQty()); // 要求发货包装容量
		twDocOrderDetails.setSupplNo(trBasPartSuppl.getSupplNo());
		twDocOrderDetails.setSoSendTime(tmMmDeliverySheetPart.getStationArriveTime());
		twDocOrderDetails.setDockId(tmMmDeliverySheet1.getSendDockId());
		twDocOrderDetails.setDockNo((String) map.get("dockNo"));// 发货道口编号',【要查的】
		twDocOrderDetails.setItemLoadStatus("0");// 状态（发运任务未产生0、发运任务产生1、部分发运2、发运完成3）',【默认0】
		twDocOrderDetails.setDeliverySend(tmMmDeliverySheet1.getDeliverySend());// 发运地
		twDocOrderDetails.setDeliveryRec(tmMmDeliverySheet1.getDeliveryRec());// 目的地
		twDocOrderDetails.setTrBasPartSupplId(tmMmDeliverySheetPart.getTrBasPartSupplId());// 零件供应商关系id

		if (ttMmManualMri.getPlantNo().equals("1")) {
			List<TmBasWh> listTmBasWorkshop = tmBasWhDao.selectTmBasWh(
					new Assist(Assist.andEq("tm_bas_wh.storage_no", tmMmDeliverySheetPart.getWarehouseNo())));
			List<TmBasDloc> listTmBasDloc = tmBasDlocDao.selectTmBasDloc(
					new Assist(Assist.andEq("tm_bas_dloc.storage_no", tmMmDeliverySheetPart.getDlocNo())));
			List<TmBasLoc> listTmBasLoc = tmBasLocDao.selectTmBasLoc(
					new Assist(Assist.andEq("tm_bas_loc.storage_no", tmMmDeliverySheetPart.getLocNo())));
			twDocOrderDetails.setpFromWarehouseId(listTmBasWorkshop.get(0).getTmBasWhId());// 来源仓库ID
			twDocOrderDetails.setpFromDlocId(listTmBasDloc.get(0).getTmBasDlocId());// 来源库区ID
			twDocOrderDetails.setpFromLocId(listTmBasLoc.get(0).getTmBasLocId()); // 来源库位ID
			twDocOrderDetails.setpFromWarehouseNo(tmMmDeliverySheetPart.getWarehouseNo());// 来源仓库编号
			twDocOrderDetails.setpFromDlocNo(tmMmDeliverySheetPart.getDlocNo());// 来源库区编号'
			twDocOrderDetails.setpFromLocNo(tmMmDeliverySheetPart.getLocNo());// 来源库位编号
		}
		// 特别需要注意的是，生成的出库订单 源库位和目标库位 从拣货库位和补货库位获取，不需要再进行分配，拣货发运的时候，直接做库存移动即可，如果库存不够就报错
		if (ttMmManualMri.getPlantNo().equals("2")) {
			// tt_mm_manual_mri
			// after_warehouse_no=补货仓库编号,after_dloc_no=补货库区编号,after_loc_no=补货库位编号,
			// dloc_no= 拣货库区编号,loc_no=拣货库位编号,warehouse_no=拣货仓库编号,
			// tw_doc_order_details 发运订单（明细）， P:源 After：目标
			twDocOrderDetails.setpFromWarehouseNo(ttMmManualMri.getWarehouseNo());// 来源仓库编号
			// twDocOrderDetails.setpFromWarehouseId(ttMmManualMri.getWarehouseNo());//来源仓库ID
			twDocOrderDetails.setpFromDlocNo(ttMmManualMri.getDlocNo());// 来源库区编号'
			// twDocOrderDetails.setpFromDlocId(ttMmManualMri.getLocNo());// 来源库区ID
			twDocOrderDetails.setpFromLocNo(ttMmManualMri.getLocNo());// 来源库位编号
			// twDocOrderDetails.setpFromLocId(ttMmManualMri.getLocNo()); // 来源库位ID

			twDocOrderDetails.setAfterPartWarehouseNo(ttMmManualMri.getAfterWarehouseNo()); // 目标仓库编号
			// twDocOrderDetails.setAfterPartWarehouse(afterPartWarehouse); // 目标仓库ID
			twDocOrderDetails.setAfterPartDlocNo(ttMmManualMri.getAfterDlocNo()); // 目标库区编号
			// twDocOrderDetails.setAfterPartDloc(afterPartDloc); // 目标库区ID
			twDocOrderDetails.setAfterPartLocNo(ttMmManualMri.getAfterLocNo()); // 目标库位编号
			// twDocOrderDetails.setAfterPartLoc(afterPartLoc); // 目标库位id
		}
		twDocOrderDetails.setMarkStatus(1);
		twDocOrderDetails.setCreateTime(new Date());
		twDocOrderDetails.setCreateUser(SpringWebUtils.getRequestCompany());
		twDocOrderDetailsDao.insertNonEmptyTwDocOrderDetails(twDocOrderDetails);
	}

	@Override
	public long getTtMmManualMriRowCount(Assist assist) {
		return ttMmManualMriDao.getTtMmManualMriRowCount(assist);
	}

	@Override
	public List<TtMmManualMri> selectTtMmManualMri(Assist assist) {
		return ttMmManualMriDao.selectTtMmManualMri(assist);
	}

	@Override
	public TtMmManualMri selectTtMmManualMriById(Integer id) {
		return ttMmManualMriDao.selectTtMmManualMriById(id);
	}

	@Override
	public int insertTtMmManualMri(TtMmManualMri value) {
		return ttMmManualMriDao.insertTtMmManualMri(value);
	}

	@Override
	public int insertNonEmptyTtMmManualMri(TtMmManualMri value) {
		return ttMmManualMriDao.insertNonEmptyTtMmManualMri(value);
	}

	@Override
	public int insertTtMmManualMriByBatch(List<TtMmManualMri> value) {
		return ttMmManualMriDao.insertTtMmManualMriByBatch(value);
	}

	@Override
	public int deleteTtMmManualMriById(Integer id) {
		return ttMmManualMriDao.deleteTtMmManualMriById(id);
	}

	@Override
	public int deleteTtMmManualMri(Assist assist) {
		return ttMmManualMriDao.deleteTtMmManualMri(assist);
	}

	@Override
	public int updateTtMmManualMriById(TtMmManualMri enti) {
		return ttMmManualMriDao.updateTtMmManualMriById(enti);
	}

	@Override
	public int updateTtMmManualMri(TtMmManualMri value, Assist assist) {
		return ttMmManualMriDao.updateTtMmManualMri(value, assist);
	}

	@Override
	public int updateNonEmptyTtMmManualMriById(TtMmManualMri enti) {
		return ttMmManualMriDao.updateNonEmptyTtMmManualMriById(enti);
	}

	@Override
	public int updateNonEmptyTtMmManualMri(TtMmManualMri value, Assist assist) {
		return ttMmManualMriDao.updateNonEmptyTtMmManualMri(value, assist);
	}

	@Override
	public void deleteAllTtMmManualMri() {
		TtMmManualMri ttMmManualMri = new TtMmManualMri();
		ttMmManualMriDao.deleteAllTtMmManualMri(ttMmManualMri);
	}

}